home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / CW GUSI 1.6.4 / Examples / GUSIINETTest.c < prev    next >
Text File  |  1995-01-23  |  10KB  |  455 lines
  1. /*********************************************************************
  2. Project    :    GUSI                -    Grand Unified Socket Interface
  3. File        :    GUSIINETTest    -    Test unix domain sockets
  4. Author    :    Matthias Neeracher <neeri@iis.ethz.ch>
  5. Language    :    MPW C
  6.  
  7. $Log: GUSIINETTest.c,v $
  8. Revision 1.1  1994/12/31  00:50:27  neeri
  9. Initial revision
  10.  
  11. Revision 0.6  1993/08/25  00:00:00  neeri
  12. gethostbyaddr()
  13.  
  14. Revision 0.5  1993/07/29  00:00:00  neeri
  15. servent tests
  16.  
  17. Revision 0.4  1993/03/03  00:00:00  neeri
  18. Added performance test
  19.  
  20. Revision 0.3  1992/09/14  00:00:00  neeri
  21. Misinterpreted hostent structure
  22.  
  23. Revision 0.2  1992/09/08  00:00:00  neeri
  24. Factor out common socket routines
  25.  
  26. Revision 0.1  1992/09/08  00:00:00  neeri
  27. First attempt
  28.  
  29. *********************************************************************/
  30.  
  31. #include <GUSI.h>
  32. #include "GUSITest.h"
  33. #include <stdio.h>
  34. #include <fcntl.h>
  35. #include <stdlib.h>
  36. #include <errno.h>
  37. #include <string.h>
  38.  
  39. #include "Events.h"
  40.  
  41. extern int GUSIDefaultSpin(spin_msg, long);
  42.  
  43. char    addrstr[100];
  44.  
  45. void Socket(char ch1, char ch2, const char * line)
  46. {
  47.     sock    =    socket(AF_INET, (ch1 == 's') ? SOCK_STREAM : SOCK_DGRAM, 0);
  48.     
  49.     if (sock == -1)    {
  50.         printf("# socket() returned error %s\n", Explain());
  51.         Where();
  52.     }
  53. }
  54.  
  55. void Bind(char ch1, char ch2, const char * cmd)
  56. {
  57.     int                        len;
  58.     struct sockaddr_in    addr;
  59.  
  60.     if (sock == -1)    {
  61.         printf("# socket is not open\n");
  62.         Where();
  63.         
  64.         return;
  65.     }
  66.  
  67.     if (sscanf(cmd, "%s %hd", addrstr, &addr.sin_port) == 2) {
  68.         addr.sin_addr            =    inet_addr(addrstr);
  69.         addr.sin_family        =    AF_INET;
  70.         len                        =    sizeof(struct sockaddr_in);
  71.     } else {
  72.         Usage(ch1, ch2);
  73.         return;
  74.     }
  75.     
  76.     if (bind(sock, (struct sockaddr *) &addr, len))    {
  77.         printf(
  78.             "bind(%s:%d) returned error %s\n", 
  79.             inet_ntoa(addr.sin_addr),
  80.             addr.sin_port, 
  81.             Explain());
  82.             
  83.         Where();
  84.     }
  85. }
  86.  
  87. void Accept(char ch1, char ch2, const char * line)
  88. {
  89.     int                        len;
  90.     struct sockaddr_in    addr;
  91.  
  92.     if (sock == -1)    {
  93.         printf("# socket is not open\n");
  94.         Where();
  95.         
  96.         return;
  97.     }
  98.     if (accsock != -1)    {
  99.         printf("# can't accept more than one connection\n");
  100.         Where();
  101.         
  102.         return;
  103.     }
  104.  
  105.     len    =    sizeof(struct sockaddr_in);
  106.     sock    =    accept(accsock = sock, (struct sockaddr *) &addr, &len);
  107.     
  108.     if (sock < 0)    {
  109.         printf("# accept() returned error %s\n", Explain());
  110.         sock        =    accsock;
  111.         accsock    =    -1;
  112.     } else {
  113.         printf(
  114.             "# accepted connection from %s port %d\n", 
  115.             inet_ntoa(addr.sin_addr), 
  116.             addr.sin_port);
  117.     }
  118.     
  119.     Where();
  120. }
  121.     
  122. void Connect(char ch1, char ch2, const char * cmd)
  123. {
  124.     int                        len;
  125.     struct sockaddr_in    addr;
  126.  
  127.     if (sock == -1)    {
  128.         printf("# socket is not open\n");
  129.         Where();
  130.         
  131.         return;
  132.     }
  133.     
  134.     if (sscanf(cmd, "%s %hd", addrstr, &addr.sin_port) == 2) {
  135.         addr.sin_addr            =    inet_addr(addrstr);
  136.         addr.sin_family        =    AF_INET;
  137.         len                        =    sizeof(struct sockaddr_in);
  138.     } else {
  139.         Usage(ch1, ch2);
  140.         return;
  141.     }
  142.  
  143.     if (connect(sock, (struct sockaddr *) &addr, len))    {
  144.         printf(
  145.             "connect(%s:%d) returned error %s\n", 
  146.             inet_ntoa(addr.sin_addr),
  147.             addr.sin_port, 
  148.             Explain());
  149.         Where();
  150.     }
  151. }    
  152.  
  153. int ReadWhileUCan()
  154. {
  155.     int                res;
  156.     char *            outline;
  157.     fd_set            rdfds;
  158.     fd_set            exfds;
  159.     struct timeval    delay;
  160.     char                 out[500];
  161.  
  162.     for (;;) {
  163.         FD_ZERO(&rdfds);
  164.         FD_ZERO(&exfds);
  165.         
  166.         FD_SET(sock, &rdfds);
  167.         FD_SET(sock, &exfds);
  168.         
  169.         delay.tv_sec    =    1;
  170.         delay.tv_usec    =    0;
  171.         
  172.         res = select(sock+1, &rdfds, nil, &exfds, &delay);
  173.         
  174.         if (res < 0)    {
  175.             printf("# select() returned error %s\n", Explain());
  176.             
  177.             return -1;
  178.         } else if (!res)
  179.             return 0;
  180.         else if (res && FD_ISSET(sock, &exfds)) {
  181.             printf("# select() returned an exception\n");
  182.             
  183.             return -1;
  184.         } else if (res && FD_ISSET(sock, &rdfds)) {
  185.             res = read(sock, out, 500);
  186.             
  187.             if (res < 0) {
  188.                 printf("# read() returned error %s\n", Explain());
  189.             
  190.                 return -1;
  191.             }
  192.             
  193.             out[res] = 0;
  194.             
  195.             for (outline = strtok(out, "\n\r"); outline; outline = strtok(nil, "\n\r"))
  196.                 printf("%s\n", outline);
  197.         }
  198.     }
  199. }
  200.  
  201. void Telnet(char ch1, char ch2, const char * cmd)
  202. {
  203.     int                len;
  204.     int                 part;
  205.     int                res;
  206.     char *            line;
  207.     char *            outline;
  208.     fd_set            rdfds;
  209.     fd_set            wrfds;
  210.     fd_set            exfds;
  211.     struct timeval    delay;
  212.     char                 in[100];
  213.     char                 out[500];
  214.     
  215.     if (sock == -1)    {
  216.         printf("# socket is not open\n");
  217.         Where();
  218.             
  219.         return;
  220.     }
  221.  
  222.     printf("# Entering Poor Man's Telnet mode\n");
  223.     
  224.     for (;;) {
  225.         if (ReadWhileUCan())
  226.             break;
  227.         
  228.         Prompt();
  229.         
  230.         if (!fgets(in, 100, input))
  231.             break;
  232.             
  233.         ++inputline;
  234.         
  235.         if (!strcmp(in, ".\n"))
  236.             break;
  237.         
  238.         if (!strcmp(in, "?\n"))
  239.             continue;
  240.  
  241.         len             = strlen(in);
  242.         in[len++]    = '\r';
  243.         in[len]        = 0;
  244.         
  245.         for (line = in; len; len -= part, line += part) {        
  246.             part = 0;
  247.  
  248.             FD_ZERO(&rdfds);
  249.             FD_ZERO(&wrfds);
  250.             FD_ZERO(&exfds);
  251.             
  252.             FD_SET(sock, &rdfds);
  253.             FD_SET(sock, &wrfds);
  254.             FD_SET(sock, &exfds);
  255.             
  256.             delay.tv_sec    =    10;
  257.             delay.tv_usec    =    0;
  258.             
  259.             res = select(sock+1, &rdfds, &wrfds, &exfds, &delay);
  260.             
  261.             if (res < 0)    {
  262.                 printf("# select() returned error %s\n", Explain());
  263.                 
  264.                 return;
  265.             } else if (!res) {
  266.                 printf("# select() timed out\n");
  267.                 
  268.                 return;
  269.             } else if (FD_ISSET(sock, &exfds)) {
  270.                 printf("# select() returned an exception\n");
  271.                 
  272.                 return;
  273.             }
  274.             
  275.             if (FD_ISSET(sock, &rdfds)) {
  276.                 res = read(sock, out, 500);
  277.                 
  278.                 if (res < 0) {
  279.                     printf("# read() returned error %s\n", Explain());
  280.                 
  281.                     return;
  282.                 }
  283.                 
  284.                 out[res] = 0;
  285.                 
  286.                 for (outline = strtok(out, "\n\r"); outline; outline = strtok(nil, "\n\r"))
  287.                     printf("%s\n", outline);
  288.             } else if (FD_ISSET(sock, &wrfds)) {
  289.                 res = write(sock, line, len);
  290.             
  291.                 if (res < 0) {
  292.                     line[strlen(line) - 2] = 0;
  293.                     printf("# write(\"%s\") returned error %s\n", line, Explain());
  294.                 
  295.                     return;
  296.                 }
  297.                 
  298.                 part = res;
  299.             }
  300.         }
  301.     }
  302.     
  303.     printf("# Leaving Poor Man's Telnet mode\n");
  304. }
  305.  
  306. void N2Addr(char ch1, char ch2, const char * cmd)
  307. {
  308.     struct in_addr        addr;
  309.     struct hostent *    ent;
  310.     
  311.     if (sscanf(cmd, "%s", addrstr) == 1)
  312.         if (ent = gethostbyname(addrstr)) {
  313.             memcpy(&addr, ent->h_addr, sizeof(struct in_addr));
  314.             printf("# gethostbyname(%s) returned %s\n", addrstr, inet_ntoa(addr));
  315.         } else
  316.             printf("# gethostbyname(%s) failed.\n", addrstr);
  317.     else
  318.         Usage(ch1, ch2);
  319. }
  320.  
  321. void A2Name(char ch1, char ch2, const char * cmd)
  322. {
  323.     struct in_addr        addr;
  324.     struct hostent *    ent;
  325.     
  326.     if (sscanf(cmd, "%s", addrstr) == 1) {
  327.         addr = inet_addr(addrstr);
  328.         if (ent = gethostbyaddr((char *) &addr, 0, 0)) {
  329.             printf("# gethostbyaddr(%s) returned %s\n", addrstr, ent->h_name);
  330.         } else
  331.             printf("# gethostbyaddr(%s) failed.\n", addrstr);
  332.     } else
  333.         Usage(ch1, ch2);
  334. }
  335.  
  336. void PerfTest(char ch1, char ch2, const char * cmd)
  337. {
  338.     int     count;
  339.     int     i;
  340.     long    ticks;
  341.     char    buf[1024];
  342.     
  343.     if (sock == -1)    {
  344.         printf("# socket is not open\n");
  345.         Where();
  346.             
  347.         return;
  348.     }
  349.  
  350.     if (sscanf(cmd, "%d", &count) == 1) {
  351.         ticks = TickCount();
  352.         for (i=0; i<count; i++) {
  353.             write(sock, buf, 1);
  354.             read(sock, buf, 1024);
  355.         } 
  356.         printf("# Did %d iterations in %d ticks.\n", count, TickCount()-ticks);
  357.     } else
  358.         Usage(ch1, ch2);
  359. }
  360.  
  361. void ServByName(char ch1, char ch2, const char * cmd)
  362. {
  363.     struct servent *    ent;
  364.     char                    proto[6];
  365.     
  366.     if (sscanf(cmd, "%s %s", addrstr, proto) == 2)
  367.         if (ent = getservbyname(addrstr, proto))
  368.             printf("# getservbyname(%s %s) returned %d\n", addrstr, proto, ent->s_port);
  369.         else
  370.             printf("# getservbyname(%s %s) failed.\n", addrstr, proto);
  371.     else if (sscanf(cmd, "%s", addrstr) == 1)
  372.         if (ent = getservbyname(addrstr, NULL))
  373.             printf("# getservbyname(%s) returned %d\n", addrstr, ent->s_port);
  374.         else
  375.             printf("# getservbyname(%s) failed.\n", addrstr);
  376.     else
  377.         Usage(ch1, ch2);
  378. }
  379.  
  380. void PrintServEnt(struct servent * ent, Boolean full)
  381. {
  382.     char    ** al;
  383.     
  384.     printf("%s", ent->s_name);
  385.     
  386.     if (full)
  387.          printf(" %d/%s", ent->s_port, ent->s_proto);
  388.         
  389.     for (al = ent->s_aliases; *al; ++al)
  390.         printf(" %s", *al);
  391.     
  392.     putchar('\n');
  393. }
  394.  
  395. void ServByPort(char ch1, char ch2, const char * cmd)
  396. {
  397.     int                    port;
  398.     struct servent *    ent;
  399.     char                    proto[6];
  400.     
  401.     if (sscanf(cmd, "%d %s", &port, proto) == 2)
  402.         if (ent = getservbyport(port, proto)) {
  403.             printf("# getservbyport(%d %s) returned ", port, proto);
  404.             
  405.             PrintServEnt(ent, false);
  406.         } else
  407.             printf("# getservbyport(%d %s) failed.\n", addrstr, proto);
  408.     else if (sscanf(cmd, "%d %s", &port) == 1)
  409.         if (ent = getservbyport(port, NULL)) {
  410.             printf("# getservbyport(%d) returned ", port);
  411.             
  412.             PrintServEnt(ent, false);
  413.         } else
  414.             printf("# getservbyport(%d) failed.\n", addrstr);
  415.     else
  416.         Usage(ch1, ch2);
  417. }
  418.  
  419. void ServList(char ch1, char ch2, const char * line)
  420. {
  421.     struct servent *    ent;
  422.     
  423.     setservent(0);
  424.     
  425.     while (ent = getservent()) {
  426.         printf("# ");
  427.         PrintServEnt(ent, true);
  428.     }
  429. }
  430.  
  431. main(int argc, char ** argv)
  432. {
  433.     GUSISetup(GUSIwithSIOUXSockets);
  434.     GUSISetup(GUSIwithInternetSockets);
  435.     
  436.     printf("GUSIINETTest        MN 25Aug93\n\n");
  437.  
  438.     COMMAND('s', 's', Socket,  "",                 "Create a stream socket");
  439.     COMMAND('d', 's', Socket,  "",                 "Create a datagram socket");
  440.     COMMAND('b', 'd', Bind,      "addr port",     "Bind to address");
  441.     COMMAND('c', 'o', Connect, "addr port",     "Connect to address");
  442.     COMMAND('a', 'c', Accept,  "",                 "Accept a connection");
  443.     COMMAND('t', 'n', Telnet,  "",                "Play telnet");
  444.     COMMAND('n', 'a', N2Addr,    "name",            "Convert name to address");
  445.     COMMAND('a', 'n', A2Name,    "addr",            "Convert address to name");
  446.     COMMAND('p', 't', PerfTest,"count",            "Do a performance test");
  447.     COMMAND('s', 'n', ServByName, "name",        "Convert service name to port number");
  448.     COMMAND('s', 'p', ServByPort, "port",        "Convert port number to service name");
  449.     COMMAND('s', 'l', ServList, "",                "List services");
  450.     
  451.     AddSocketCommands();
  452.     
  453.     RunTest(argc, argv);
  454.     CleanupSockets();
  455. }